package com.xiangge.demo;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class DemoTest1 {
    public static void main(String[] args) {
        int[] arr1 = getOne();
        System.out.println(Arrays.toString(arr1));
    }
    // 定义一个无参有返回值的方法
    public static int[] getOne(){
        // 定义一个长度为7的数组
        int[] arr = new int[7];
        // 随机生成六个数，且不能重复
        Random random = new Random();
        // 双色球将前六个和最后一个分开，那就分开遍历
        // 先遍历红球,少一个蓝球位置，所以遍历的索引减一
        for (int i = 0; i < arr.length-1; i++) {

            // 不知道要生成几次，使用while
            while (true){
                int num = random.nextInt(33) + 1;
                // 要判断随机生成的数是否存在
                boolean flag = true;
                for (int j = 0; j < i; j++) {
                    if (arr[j] == num){
                        flag = false;
                        break;
                    }
                }
                if (flag == true){
                    arr[i] = num;
                    break;
                }
            }
        }
        arr[arr.length-1] = random.nextInt(16) + 1;
        return arr;
    }

    public static void main4(String[] args) {
        /*
        一个大V直播抽奖，奖品是现金红包，分别有
        {2, 588 , 888, 1000, 10000}五个奖金。
        请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
        打印效果如下：（随机顺序，不一定是下面的顺序）
            888元的奖金被抽出
            588元的奖金被抽出
            10000元的奖金被抽出
            1000元的奖金被抽出
            2元的奖金被抽出
        */
        // 将奖金作为元素创建数组
        int[] arr = {2, 588, 888, 1000, 10000};
        // 再创建一个新数组用来存放已经被抽取过的奖金
        int[] newArr = new int[5];
        // 将抽中的奖项放入新数组中，先对新数组进行遍历
        for (int i = 0; i < newArr.length; i++) {
            // 题目要求奖金出现是随机且不重复的，那当出现奖项重复时，重新抽奖
            // 不知道抽多少次才可以抽到所有奖项，是死循环使用while（true）
            while (true){
                // 抽奖是随机生成，使用Random
                Random random = new Random();
                // 定义一个索引，使用随机数赋值，用索引来判断抽到的奖项
                int index = random.nextInt(arr.length);
                // 创建临时变量，来表示存入新数组的奖金金额
                int money = arr[index];
                // 定义boolean类型，来判断奖项是否被抽取过
                boolean flag = true;
                // 遍历新数组，判断奖项是否出现过
                for (int j = 0; j < newArr.length; j++) {
                    // 使用if结构判断
                    if (newArr[j] == money){
                        flag = false;
                        break;
                    }
                }
                // 可以存入数组，奖金没被抽取过
                if (flag == true){
                    newArr[i] = money;
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(newArr));
        for (int k = 0; k < newArr.length; k++) {
            System.out.println(newArr[k]);
        }
    }
    public static void main3(String[] args) {
        /*
        某系统的数字密码，比如1983，采用加密方式进行传输，规则如下：
        先得到每位数，然后每位数都加上5 , 再对10求余，最后将所有数字反转，得到一串新数。
        1       9       8       3
            +5
        6       14      13      8
            %10
        6       4       3       8
            反转
        8       3       4       6
        */
        // 创建一个长度为4的数组，键盘录入四位数值
        int[] arr = new int[4];
        // 遍历数组，使用键盘录入四次
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入数组中第" + (i+1) +"个元素：");
            int num = new Scanner(System.in).nextInt();
            arr[i] = num;
        }
        // 对数组的每一个元素进行+5，%10的操作,变成一个新的元素
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }
        // 进行数组的反转
        // 先创建一个临时变量
        int temp = 0;
        // 遍历数组进行反转,创建两个指针i，j，分别从前后开始遍历数组
        for (int i = 0,j = arr.length-1; i <= j; i++,j--) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        // 使用Array工具查看最后生成的数组
        System.out.println(Arrays.toString(arr));
    }
    public static void main2(String[] args) {
        /*
        在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。
        选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，
        请完成上述过程并计算出选手的得分。
        */
        // 有6位评委打分，将分数组成数组，评委打分使用循环实现
        // 定义长度为6的int类型数组
        int[] arr = new int[6];
        // 评委手动打分也就是键盘录入
        Scanner sc = new Scanner(System.in);
        // 使用for循环，将评委打分进行六次键盘录入
        for (int i = 0; i < 6; i++) {
            // 手动录入
            System.out.println("请第" + (i+1) + "位评委打分：");
            arr[i] = sc.nextInt();
            // 分数有范围，使用if单选结构做规范
            if (arr[i] < 0 || arr[i] > 100){
                System.err.println("分数超额");
                return;
            }
        }
        // 要去掉最高分和最低分，那就要再定义int类型变量，遍历数组进行比较
        // 假设数组的第一个元素就是最大值，最小值
        // 同时定位最大值，最小值的索引位置
        int max = arr[0];
        int maxIndex = 0;
        int min = arr[0];
        int minIndex = 0;
        // 遍历数组
        for (int i = 0; i < 6; i++) {
            // 使用if语句判断
            if (max < arr[i]){
                max = arr[i];
                maxIndex = i;
            }
            if (min > arr[i]){
                min = arr[i];
                minIndex = i;
            }
        }
        // 创建一个新数组，将arr数组排除最大值和最小值后的元素放入
        int[] newArr = new int[4];
        // 新数组的索引用index定义
        int index = 0;
        // 遍历arr数组，同时用if语句判断将元素放入
        loop:for (int i = 0; i < 6; i++) {
            if (i != maxIndex && i != minIndex){
                newArr[index] = arr[i];
                index++;
                // 再循环内进行index的条件判断
                if (index == 4){
                    break loop;
                }
            }
        }
        System.out.println(Arrays.toString(newArr));
        // 再遍历新数组，求新数组的和
        // 要求和先定义总分sum和平均分avg
        int sum = 0;
        double avg = 0.0;
        for (int i = 0; i < newArr.length; i++) {
            sum += newArr[i];
        }
        // 输出平均值sum / newArr.length --> sum / 4
        avg = sum / 4;
        System.out.println("选手的得分是：" + avg);
    }
    public static void main1(String[] args) {
        /*
        把一个数组中的元素复制到另一个新数组中去。去重
       {1, 3,5,7, 9, 1, 0, 1,5}
       --->  {1, 3,5, 7, 9,  0}
*/
        // 定义已知数组
        int[] arr = {1, 3, 5, 7, 9, 1, 0, 1, 5};
        // 遍历数组arr
        // 第一次循环遍历数组，得到每个元素
        for (int i = 0; i < arr.length; i++) {
            // 第二次遍历数组arr，是与第一次遍历得到的元素相比，如果相同将相同的元素变为-1
            // 因为是与第一次遍历相比，所以直接从第一次遍历的后一个元素开始
            for (int j = i + 1; j < arr.length; j++) {
                // if结构判断,如果有相同的元素
                if (arr[i] == arr[j]){
                    // 第二次遍历的元素替换为-1
                    arr[j] = -1;
                }
            }
        }
        // 统计arr数组中有多少个-1
        int count = 0;
        // 遍历数组arr
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == -1){
                count++;
            }
        }
        // 创建一个新数组，长度为arr.length-count
        int[] newArr = new int[arr.length-count];
        // 准备新数组中元素存储的索引位置
        int index = 0;
        // 再遍历一遍arr数组，将数组中元素不为-1的放入新数组中
        loop:for (int i = 0; i < arr.length; i++) {
            if (arr[i] != -1){
                // index定义的初始值为0，也就是newArr数组的索引0与arr数组的索引0
                newArr[index] = arr[i];
                // 每录入一次，将newArr数组的索引往前进一位
                index++;
                if (index == newArr.length){
                    break loop;
                }
            }
        }
        System.out.println(Arrays.toString(newArr));
    }

    public static void mainW(String[] args) {
        // 调用getWord方法
        String a = getWord();
        System.out.println(a);
    }
    /*
        登录系统 账号：admin
               密码：123456
           定义方法实现随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。
    */
    // 定义一个无参有返回值的方法
    public static String getWord(){
        // 根据题目要求首先要构建一个数组，其中包含数组，字母大小写
        char[] arr = {
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
                'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
                'U', 'V', 'W', 'X', 'Y', 'Z',
                'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
                'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
                'u', 'v', 'w', 'x', 'y', 'z'
        };
        // 创建一个字符串作为返回值
        String str = " ";
        // 要随机生成5个数，放在for循环中将Random循环5次
        for (int i = 0; i < 5; i++) {
            int random = new Random().nextInt(arr.length);
            // 题目要求要使用数字或字母大小写，那就要从arr数组中寻找，random的范围也就定在arr数组的长度内了
            // 所以将这里生成的随机数作为arr数组的索引，将对应的值赋给生成位置
            // 创建int类型的index作为索引
            int index = random;
            // String类型字符串相加就是字符组合
            str = str + arr[index];
        }
        // 最后返回main方法
        return str;
    }

    public static void mainS(String[] args) {
        // 调用getSuShu方法
        getSuShu();
    }
    /*
        判断101-200之间有多少个素数，并输出所有素数
    */
    // 定义一个无参无返回值的方法
    public static void getSuShu(){
        // 要统计素数的个数，那就定义一个int类型的变量来计数
        int count = 0;
        // 从101开到变量200为止，判断他之前是否能被其他正整数整除
        for (int i = 101; i < 201; i++) {
            // 假设该数为素数
            boolean su = true;
            // 素数的判断要从2开始，要再次进行遍历
            for (int j = 2; j < i; j++) {
                // 使用if单选结构判断
                if (i % j == 0){
                    su = false;
                    break;
                }
            }
            // 在循环外再进行判断
            if (su == true){
                System.out.println(i + "是素数");
                count++;
            }
        }
        System.out.println("在101-200之间有" + count + "个素数");
    }

    public static void mainP(String[] args) {
        // 键盘录入月份，票价和舱型
        Scanner input = new Scanner(System.in);
        // 键盘录入月份
        System.out.println("请输入搭乘月份：");
        int month = input.nextInt();
        // 使用if单选结构排除月份输入错误的情况
        if (month < 1 || month > 12){
            System.err.println("输入的月份有误！");
            return;
        }
        // 键盘录入票价
        System.out.println("请输入搭乘票价：");
        double price = input.nextDouble();
        // 使用if单选结构排除票价输入错误的情况
        if (price < 0 || price > 10000){
            System.err.println("输入的票价有误！");
            return;
        }
        // 键盘录入舱型
        System.out.println("请输入搭乘舱型：");
        String str = input.next();
        // 使用if单选结构排除舱型输入错误的情况
        // 字符串String的条件判断不能直接使用 == 或 ！= ，这样只能访问字符串的地址，不能进行内容比较
        // 所以这里的字符串String的内容比较,使用equals方法，（变量）.equals(变量名)
        if (!"头等舱".equals(str) && "经济舱".equals(str)){
            System.err.println("输入的舱型有误！");
            return;
        }
        // 调用getPrice方法
        getPrice(month,price,str);
    }
    /*
        机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
        按照如下规则计算机票价格：
        旺季（5-10月）头等舱9折，经济舱8.5折，
        淡季（11月到来年4月）头等舱7折，经济舱6.5折。
        */
    // 定义一个有参无返回值的方法
    public static void getPrice(int month, double price, String str){
        // 首先使用switch方法来判断购买的是头等舱还是经济舱
        switch (str){
            case "头等舱":
                // 使用if语句判断
                if (month >= 5 && month <= 10){
                    System.out.println("你的机票折后价格为：" + (price * 0.9));
                }else {
                    System.out.println("你的机票折后价格为：" + (price * 0.85));
                }
                break;
            case "经济舱":
                // 使用if语句判断
                if (month >= 5 && month <= 10){
                    System.out.println("你的机票折后价格为：" + (price * 0.7));
                }else {
                    System.out.println("你的机票折后价格为：" + (price * 0.65));
                }
                break;
        }
    }
}
